/* Copyright ©, 2023, ECARX (Hubei) Technology Co., Ltd. All rights reserved.
 *
 * NOTICE: This file contains information which is confidential and proprietary to ECARX
 * (Hubei) Technology Co., Ltd. and/or other developers. No license to any intellectual
 * property rights contained within this file is either granted or implied except as may be
 * provided in an agreement with ECARX (Hubei) Technology Co., Ltd.
 *
 * Any unauthorized copying or distribution of content from this file in whole or in part
 * is prohibited.
 */
#pragma once

#include <vector>
#include <transfer/common.h>
#include <arpa/inet.h>
#include <map>
#include <ipcp/ipcp.h>
#include <functional>

#include "ap/APCP_signal_id.h"
#include "common.h"
#include "cp/CP_ServiceId.h"
#include "cp/Normal.h"
#include "cp/AVAS.h"
#include "cp/TimeSync.h"
#include "cp/HostInfo.h"
#include "cp/Power.h"
    
namespace ecarx::transfer::utils {
    
    std::vector<Signal> cpIpcpValueToSignal(const ipcp::IpcpValue &ipcpValue){
        std::vector<Signal> signals = {};
        // CP_serviceID_Invalid
        if (ipcpValue.service_id == CP_serviceID_Invalid) {
            return signals;
        }/**/
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == CpNormalStatusOpId) {
            OpCpNormalStatus_Notify signal;
            int bufferLength = (int) sizeof(OpCpNormalStatus_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::CpNormalStatus,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == OdoInfoOpId) {
            constexpr int structLen = (int) sizeof(OpOdoInfo_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpOdoInfo_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::OdoInfo;
            signal.value.bytes.resize(sizeof(OpOdoInfo_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpOdoInfo_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1MileageOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1Mileage_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1Mileage_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1Mileage;
            signal.value.bytes.resize(sizeof(OpTrip1Mileage_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1Mileage_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1EgyUseOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1EgyUse_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1EgyUse_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1EgyUse;
            signal.value.bytes.resize(sizeof(OpTrip1EgyUse_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1EgyUse_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1EgyRecOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1EgyRec_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1EgyRec_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1EgyRec;
            signal.value.bytes.resize(sizeof(OpTrip1EgyRec_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1EgyRec_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1AVSOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1AVS_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1AVS_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1AVS;
            signal.value.bytes.resize(sizeof(OpTrip1AVS_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1AVS_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1EDTOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1EDT_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1EDT_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1EDT;
            signal.value.bytes.resize(sizeof(OpTrip1EDT_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1EDT_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2MileageOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2Mileage_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2Mileage_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2Mileage;
            signal.value.bytes.resize(sizeof(OpTrip2Mileage_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2Mileage_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2EgyUseOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2EgyUse_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2EgyUse_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2EgyUse;
            signal.value.bytes.resize(sizeof(OpTrip2EgyUse_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2EgyUse_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2EgyRecOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2EgyRec_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2EgyRec_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2EgyRec;
            signal.value.bytes.resize(sizeof(OpTrip2EgyRec_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2EgyRec_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2AVSOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2AVS_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2AVS_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2AVS;
            signal.value.bytes.resize(sizeof(OpTrip2AVS_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2AVS_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2EDTOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2EDT_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2EDT_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2EDT;
            signal.value.bytes.resize(sizeof(OpTrip2EDT_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2EDT_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == LeFrntTireMsgPSyncOpId) {
            constexpr int structLen = (int) sizeof(OpLeFrntTireMsgPSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpLeFrntTireMsgPSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::LeFrntTireMsgPSync;
            signal.value.bytes.resize(sizeof(OpLeFrntTireMsgPSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpLeFrntTireMsgPSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == RiFrntTireMsgPSyncOpId) {
            constexpr int structLen = (int) sizeof(OpRiFrntTireMsgPSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpRiFrntTireMsgPSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::RiFrntTireMsgPSync;
            signal.value.bytes.resize(sizeof(OpRiFrntTireMsgPSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpRiFrntTireMsgPSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == LeReTireMsgPSyncOpId) {
            constexpr int structLen = (int) sizeof(OpLeReTireMsgPSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpLeReTireMsgPSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::LeReTireMsgPSync;
            signal.value.bytes.resize(sizeof(OpLeReTireMsgPSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpLeReTireMsgPSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == RiReTireMsgPSyncOpId) {
            constexpr int structLen = (int) sizeof(OpRiReTireMsgPSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpRiReTireMsgPSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::RiReTireMsgPSync;
            signal.value.bytes.resize(sizeof(OpRiReTireMsgPSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpRiReTireMsgPSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == LeFrntTireMsgTSyncOpId) {
            constexpr int structLen = (int) sizeof(OpLeFrntTireMsgTSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpLeFrntTireMsgTSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::LeFrntTireMsgTSync;
            signal.value.bytes.resize(sizeof(OpLeFrntTireMsgTSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpLeFrntTireMsgTSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == RiFrntTireMsgTSyncOpId) {
            constexpr int structLen = (int) sizeof(OpRiFrntTireMsgTSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpRiFrntTireMsgTSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::RiFrntTireMsgTSync;
            signal.value.bytes.resize(sizeof(OpRiFrntTireMsgTSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpRiFrntTireMsgTSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == LeReTireMsgTSyncOpId) {
            constexpr int structLen = (int) sizeof(OpLeReTireMsgTSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpLeReTireMsgTSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::LeReTireMsgTSync;
            signal.value.bytes.resize(sizeof(OpLeReTireMsgTSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpLeReTireMsgTSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == RiReTireMsgTSyncOpId) {
            constexpr int structLen = (int) sizeof(OpRiReTireMsgTSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpRiReTireMsgTSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::RiReTireMsgTSync;
            signal.value.bytes.resize(sizeof(OpRiReTireMsgTSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpRiReTireMsgTSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == LeFrntTireSymbolSyncOpId) {
            constexpr int structLen = (int) sizeof(OpLeFrntTireSymbolSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpLeFrntTireSymbolSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::LeFrntTireSymbolSync;
            signal.value.bytes.resize(sizeof(OpLeFrntTireSymbolSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpLeFrntTireSymbolSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == RiFrntTireSymbolSyncOpId) {
            constexpr int structLen = (int) sizeof(OpRiFrntTireSymbolSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpRiFrntTireSymbolSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::RiFrntTireSymbolSync;
            signal.value.bytes.resize(sizeof(OpRiFrntTireSymbolSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpRiFrntTireSymbolSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == LeReTireSymbolSyncOpId) {
            constexpr int structLen = (int) sizeof(OpLeReTireSymbolSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpLeReTireSymbolSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::LeReTireSymbolSync;
            signal.value.bytes.resize(sizeof(OpLeReTireSymbolSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpLeReTireSymbolSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == RiReTireSymbolSyncOpId) {
            constexpr int structLen = (int) sizeof(OpRiReTireSymbolSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpRiReTireSymbolSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::RiReTireSymbolSync;
            signal.value.bytes.resize(sizeof(OpRiReTireSymbolSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpRiReTireSymbolSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == WheelKeyEventAdasOpId) {
            OpWheelKeyEventAdas_Notify signal;
            int bufferLength = (int) sizeof(OpWheelKeyEventAdas_Notify);
            if (ipcpValue.payload_len < bufferLength) {
            bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(7);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyTop,
                    .value.int32Values = {signal.mAdasHardKeyTop}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyBottom,
                    .value.int32Values = {signal.mAdasHardKeyBottom}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyLeft,
                    .value.int32Values = {signal.mAdasHardKeyLeft}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyRight,
                    .value.int32Values = {signal.mAdasHardKeyRight}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyConfirm,
                    .value.int32Values = {signal.mAdasHardKeyConfirm}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyResume,
                    .value.int32Values = {signal.mAdasHardKeyResume}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AdasHardKeyCancel,
                    .value.int32Values = {signal.mAdasHardKeyCancel}
            });

        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == WheelKeyEventUserOpId) {
            OpWheelKeyEventUser_Notify signal;
            int bufferLength = (int) sizeof(OpWheelKeyEventUser_Notify);
            if (ipcpValue.payload_len < bufferLength) {
            bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(9);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyTop,
                    .value.int32Values = {signal.mHardKeyTop}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyBottom,
                    .value.int32Values = {signal.mHardKeyBottom}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyLeft,
                    .value.int32Values = {signal.mHardKeyLeft}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyRight,
                    .value.int32Values = {signal.mHardKeyRight}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyConfirm,
                    .value.int32Values = {signal.mHardKeyConfirm}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyVR,
                    .value.int32Values = {signal.mHardKeyVR}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyCustom,
                    .value.int32Values = {signal.mHardKeyCustom}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyMenu,
                    .value.int32Values = {signal.mHardKeyMenu}
            });
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HardKeyMute,
                    .value.int32Values = {signal.mHardKeyMute}
            });

        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == WheelKeyModeSyncOpId) {
            OpWheelKeyModeSync_Notify signal;
            int bufferLength = (int) sizeof(OpWheelKeyModeSync_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::WheelKeyModeSync,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == DTEChrgInfoOpId) {
            constexpr int structLen = (int) sizeof(OpDTEChrgInfo_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDTEChrgInfo_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DTEChrgInfo;
            signal.value.bytes.resize(sizeof(OpDTEChrgInfo_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDTEChrgInfo_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == VehSpdIndcdInfoOpId) {
            constexpr int structLen = (int) sizeof(OpVehSpdIndcdInfo_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpVehSpdIndcdInfo_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::VehSpdIndcdInfo;
            signal.value.bytes.resize(sizeof(OpVehSpdIndcdInfo_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpVehSpdIndcdInfo_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == DTEFuelInfoOpId) {
            constexpr int structLen = (int) sizeof(OpDTEFuelInfo_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDTEFuelInfo_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DTEFuelInfo;
            signal.value.bytes.resize(sizeof(OpDTEFuelInfo_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDTEFuelInfo_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == SoundVolLvlOpId) {
            OpSoundVolLvl_Notify signal;
            int bufferLength = (int) sizeof(OpSoundVolLvl_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::SoundVolLvl,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == CPLogSyncOpId) {
            constexpr int structLen = (int) sizeof(OpCPLogSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpCPLogSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::CPLogSync;
            signal.value.bytes.resize(sizeof(OpCPLogSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpCPLogSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == DTEInfoOpId) {
            constexpr int structLen = (int) sizeof(OpDTEInfo_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDTEInfo_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DTEInfo;
            signal.value.bytes.resize(sizeof(OpDTEInfo_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDTEInfo_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == ChrgRemainPercentOpId) {
            constexpr int structLen = (int) sizeof(OpChrgRemainPercent_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpChrgRemainPercent_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::ChrgRemainPercent;
            signal.value.bytes.resize(sizeof(OpChrgRemainPercent_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpChrgRemainPercent_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == FuelRemainPercentOpId) {
            OpFuelRemainPercent_Notify signal;
            int bufferLength = (int) sizeof(OpFuelRemainPercent_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::FuelRemainPercent,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1AFCOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1AFC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1AFC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1AFC;
            signal.value.bytes.resize(sizeof(OpTrip1AFC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1AFC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip1AECOpId) {
            constexpr int structLen = (int) sizeof(OpTrip1AEC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip1AEC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip1AEC;
            signal.value.bytes.resize(sizeof(OpTrip1AEC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip1AEC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2AFCOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2AFC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2AFC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2AFC;
            signal.value.bytes.resize(sizeof(OpTrip2AFC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2AFC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip2AECOpId) {
            constexpr int structLen = (int) sizeof(OpTrip2AEC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip2AEC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip2AEC;
            signal.value.bytes.resize(sizeof(OpTrip2AEC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip2AEC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == SeScrShrRpsOpId) {
            OpSeScrShrRps_Notify signal;
            int bufferLength = (int) sizeof(OpSeScrShrRps_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::SeScrShrRps,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == ACCICCStsOpId) {
            OpACCICCSts_Notify signal;
            int bufferLength = (int) sizeof(OpACCICCSts_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::ACCICCSts,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == DIMViewStsOpId) {
            OpDIMViewSts_Notify signal;
            int bufferLength = (int) sizeof(OpDIMViewSts_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::DIMViewSts,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == ODO200mElcUseOpId) {
            OpODO200mElcUse_Notify signal;
            int bufferLength = (int) sizeof(OpODO200mElcUse_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::ODO200mElcUse,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == ODO200mFueUseOpId) {
            OpODO200mFueUse_Notify signal;
            int bufferLength = (int) sizeof(OpODO200mFueUse_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::ODO200mFueUse,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == NavActvMenuReqSyncOpId) {
            OpNavActvMenuReqSync_Notify signal;
            int bufferLength = (int) sizeof(OpNavActvMenuReqSync_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::NavActvMenuReqSync,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_TimegapOpId) {
            constexpr int structLen = (int) sizeof(OpAD_Timegap_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_Timegap_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_Timegap;
            signal.value.bytes.resize(sizeof(OpAD_Timegap_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_Timegap_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_AdjustTimeGapOpId) {
            constexpr int structLen = (int) sizeof(OpAD_AdjustTimeGap_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_AdjustTimeGap_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_AdjustTimeGap;
            signal.value.bytes.resize(sizeof(OpAD_AdjustTimeGap_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_AdjustTimeGap_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_LongitudinalStatus_LampOpId) {
            constexpr int structLen = (int) sizeof(OpAD_LongitudinalStatus_Lamp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_LongitudinalStatus_Lamp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_LongitudinalStatus_Lamp;
            signal.value.bytes.resize(sizeof(OpAD_LongitudinalStatus_Lamp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_LongitudinalStatus_Lamp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_Longitudina_AdjustSetSpeedOpId) {
            constexpr int structLen = (int) sizeof(OpAD_Longitudina_AdjustSetSpeed_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_Longitudina_AdjustSetSpeed_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_Longitudina_AdjustSetSpeed;
            signal.value.bytes.resize(sizeof(OpAD_Longitudina_AdjustSetSpeed_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_Longitudina_AdjustSetSpeed_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_AdasTTPaOpId) {
            constexpr int structLen = (int) sizeof(OpAD_AdasTTPa_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_AdasTTPa_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_AdasTTPa;
            signal.value.bytes.resize(sizeof(OpAD_AdasTTPa_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_AdasTTPa_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_TSIOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_TSI_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_TSI_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_TSI;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_TSI_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_TSI_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_MovObject_NOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_MovObject_N_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_MovObject_N_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_MovObject_N;
            signal.value.bytes.resize(sizeof(OpAD_PA_MovObject_N_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_MovObject_N_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_StaObject_NOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_StaObject_N_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_StaObject_N_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_StaObject_N;
            signal.value.bytes.resize(sizeof(OpAD_PA_StaObject_N_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_StaObject_N_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_LineOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_Line_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_Line_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_Line;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_Line_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_Line_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_Line_FuncOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_Line_Func_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_Line_Func_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_Line_Func;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_Line_Func_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_Line_Func_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_FCTAOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_FCTA_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_FCTA_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_FCTA;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_FCTA_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_FCTA_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_RCWOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_RCW_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_RCW_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_RCW;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_RCW_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_RCW_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_StopLineOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_StopLine_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_StopLine_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_StopLine;
            signal.value.bytes.resize(sizeof(OpAD_PA_StopLine_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_StopLine_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_CrossWalkDispOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_CrossWalkDisp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_CrossWalkDisp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_CrossWalkDisp;
            signal.value.bytes.resize(sizeof(OpAD_PA_CrossWalkDisp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_CrossWalkDisp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_ArrowOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_Arrow_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_Arrow_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_Arrow;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_Arrow_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_Arrow_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_LineRampOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_LineRamp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_LineRamp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_LineRamp;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_LineRamp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_LineRamp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_TLA_LAMPOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_TLA_LAMP_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_TLA_LAMP_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_TLA_LAMP;
            signal.value.bytes.resize(sizeof(OpAD_PA_TLA_LAMP_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_TLA_LAMP_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_DOWOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_DOW_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_DOW_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_DOW;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_DOW_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_DOW_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_BoundaryWarnOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_BoundaryWarn_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_BoundaryWarn_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_BoundaryWarn;
            signal.value.bytes.resize(sizeof(OpAD_PA_BoundaryWarn_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_BoundaryWarn_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_LCAleft_animationOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_LCAleft_animation_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_LCAleft_animation_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_LCAleft_animation;
            signal.value.bytes.resize(sizeof(OpAD_PA_LCAleft_animation_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_LCAleft_animation_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_LCAright_animationOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_LCAright_animation_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_LCAright_animation_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_LCAright_animation;
            signal.value.bytes.resize(sizeof(OpAD_PA_LCAright_animation_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_LCAright_animation_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_LaneChangeDispOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_LaneChangeDisp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_LaneChangeDisp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_LaneChangeDisp;
            signal.value.bytes.resize(sizeof(OpAD_PA_LaneChangeDisp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_LaneChangeDisp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_VehiclePathDispOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_VehiclePathDisp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_VehiclePathDisp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_VehiclePathDisp;
            signal.value.bytes.resize(sizeof(OpAD_PA_VehiclePathDisp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_VehiclePathDisp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_G_pilot_DIMLightDispOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_G_pilot_DIMLightDisp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_G_pilot_DIMLightDisp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_G_pilot_DIMLightDisp;
            signal.value.bytes.resize(sizeof(OpAD_PA_G_pilot_DIMLightDisp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_G_pilot_DIMLightDisp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_SC_OverrideOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_SC_Override_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_SC_Override_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_SC_Override;
            signal.value.bytes.resize(sizeof(OpAD_PA_SC_Override_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_SC_Override_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_LateralOffsetDispOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_LateralOffsetDisp_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_LateralOffsetDisp_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_LateralOffsetDisp;
            signal.value.bytes.resize(sizeof(OpAD_PA_LateralOffsetDisp_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_LateralOffsetDisp_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_ADAS_TunnelOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_ADAS_Tunnel_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_ADAS_Tunnel_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_ADAS_Tunnel;
            signal.value.bytes.resize(sizeof(OpAD_PA_ADAS_Tunnel_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_ADAS_Tunnel_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_TLA_LeftLAMPOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_TLA_LeftLAMP_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_TLA_LeftLAMP_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_TLA_LeftLAMP;
            signal.value.bytes.resize(sizeof(OpAD_PA_TLA_LeftLAMP_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_TLA_LeftLAMP_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_TLA_RightLAMPOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_TLA_RightLAMP_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_TLA_RightLAMP_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_TLA_RightLAMP;
            signal.value.bytes.resize(sizeof(OpAD_PA_TLA_RightLAMP_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_TLA_RightLAMP_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == AD_PA_VehiclePathDisp_FuncOpId) {
            constexpr int structLen = (int) sizeof(OpAD_PA_VehiclePathDisp_Func_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpAD_PA_VehiclePathDisp_Func_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::AD_PA_VehiclePathDisp_Func;
            signal.value.bytes.resize(sizeof(OpAD_PA_VehiclePathDisp_Func_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpAD_PA_VehiclePathDisp_Func_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == MaintainInfoSyncOpId) {
            constexpr int structLen = (int) sizeof(OpMaintainInfoSync_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpMaintainInfoSync_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::MaintainInfoSync;
            signal.value.bytes.resize(sizeof(OpMaintainInfoSync_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpMaintainInfoSync_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == FaultAlarmNofitfyOpId) {
            constexpr int structLen = (int) sizeof(OpFaultAlarmNofitfy_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpFaultAlarmNofitfy_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::FaultAlarmNofitfy;
            signal.value.bytes.resize(sizeof(OpFaultAlarmNofitfy_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpFaultAlarmNofitfy_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == HudActvStatusOpId) {
            OpHudActvStatus_Notify signal;
            int bufferLength = (int) sizeof(OpHudActvStatus_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HudActvStatus,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == HudSnowModeStsOpId) {
            OpHudSnowModeSts_Notify signal;
            int bufferLength = (int) sizeof(OpHudSnowModeSts_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::HudSnowModeSts,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip3MileageOpId) {
            constexpr int structLen = (int) sizeof(OpTrip3Mileage_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip3Mileage_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip3Mileage;
            signal.value.bytes.resize(sizeof(OpTrip3Mileage_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip3Mileage_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip3AVSOpId) {
            constexpr int structLen = (int) sizeof(OpTrip3AVS_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip3AVS_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip3AVS;
            signal.value.bytes.resize(sizeof(OpTrip3AVS_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip3AVS_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip3EDTOpId) {
            constexpr int structLen = (int) sizeof(OpTrip3EDT_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip3EDT_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip3EDT;
            signal.value.bytes.resize(sizeof(OpTrip3EDT_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip3EDT_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip3AFCOpId) {
            constexpr int structLen = (int) sizeof(OpTrip3AFC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip3AFC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip3AFC;
            signal.value.bytes.resize(sizeof(OpTrip3AFC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip3AFC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip3AECOpId) {
            constexpr int structLen = (int) sizeof(OpTrip3AEC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip3AEC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip3AEC;
            signal.value.bytes.resize(sizeof(OpTrip3AEC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip3AEC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == Trip0AECOpId) {
            constexpr int structLen = (int) sizeof(OpTrip0AEC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTrip0AEC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::Trip0AEC;
            signal.value.bytes.resize(sizeof(OpTrip0AEC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTrip0AEC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == TripIECOpId) {
            constexpr int structLen = (int) sizeof(OpTripIEC_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpTripIEC_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::TripIEC;
            signal.value.bytes.resize(sizeof(OpTripIEC_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpTripIEC_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Normal
                && ipcpValue.oper_id == DispTypOfElecDstToEmptyOpId) {
            OpDispTypOfElecDstToEmpty_Notify signal;
            int bufferLength = (int) sizeof(OpDispTypOfElecDstToEmpty_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::DispTypOfElecDstToEmpty,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_TimeSync
                && ipcpValue.oper_id == CpTimeSyncStatusOpId) {
            OpCpTimeSyncStatus_Notify signal;
            int bufferLength = (int) sizeof(OpCpTimeSyncStatus_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::CpTimeSyncStatus,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_AVAS
                && ipcpValue.oper_id == CpAVASStatusOpId) {
            OpCpAVASStatus_Notify signal;
            int bufferLength = (int) sizeof(OpCpAVASStatus_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::CpAVASStatus,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_AVAS
                && ipcpValue.oper_id == AvasDiagnosisStsOpId) {
            OpAvasDiagnosisSts_Notify signal;
            int bufferLength = (int) sizeof(OpAvasDiagnosisSts_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::AvasDiagnosisSts,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_HostInfo
                && ipcpValue.oper_id == CSDTvalueOpId) {
            OpCSDTvalue_Notify signal;
            int bufferLength = (int) sizeof(OpCSDTvalue_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::CSDTvalue,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        else if(ipcpValue.service_id == CP_serviceID_HostInfo
                && ipcpValue.oper_id == DIDD0D0OpId) {
            constexpr int structLen = (int) sizeof(OpDIDD0D0_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDIDD0D0_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DIDD0D0;
            signal.value.bytes.resize(sizeof(OpDIDD0D0_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDIDD0D0_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_HostInfo
                && ipcpValue.oper_id == DIDD0D1OpId) {
            constexpr int structLen = (int) sizeof(OpDIDD0D1_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDIDD0D1_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DIDD0D1;
            signal.value.bytes.resize(sizeof(OpDIDD0D1_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDIDD0D1_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_HostInfo
                && ipcpValue.oper_id == DIDD089OpId) {
            constexpr int structLen = (int) sizeof(OpDIDD089_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDIDD089_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DIDD089;
            signal.value.bytes.resize(sizeof(OpDIDD089_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDIDD089_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_HostInfo
                && ipcpValue.oper_id == DIDC006OpId) {
            constexpr int structLen = (int) sizeof(OpDIDC006_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDIDC006_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DIDC006;
            signal.value.bytes.resize(sizeof(OpDIDC006_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDIDC006_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_HostInfo
                && ipcpValue.oper_id == DIDD07FOpId) {
            constexpr int structLen = (int) sizeof(OpDIDD07F_Notify);
            int bufferLength = structLen;
            if (ipcpValue.payload_len < structLen) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            OpDIDD07F_Notify data;
            memcpy(&data, ipcpValue.payload, bufferLength);
            Signal signal;
            signal.signalId = (int32_t)APCPSignalRX::DIDD07F;
            signal.value.bytes.resize(sizeof(OpDIDD07F_Notify), 0);
            memcpy(signal.value.bytes.data(), &data, sizeof(OpDIDD07F_Notify));
            signals.emplace_back(signal);
        }      
        else if(ipcpValue.service_id == CP_serviceID_Power
                && ipcpValue.oper_id == StatusRequest2ApOpId) {
            OpStatusRequest2Ap_Notify signal;
            int bufferLength = (int) sizeof(OpStatusRequest2Ap_Notify);
            if (ipcpValue.payload_len < bufferLength) {
                bufferLength = ipcpValue.payload_len;
            }
            signals.reserve(1);
            memcpy(&signal, ipcpValue.payload, bufferLength);
            signals.emplace_back(Signal{
                    .signalId=(int32_t)APCPSignalRX::StatusRequest2Ap,
                    .value.int32Values = {(int32_t)signal.value}
            });
        }
        return signals;
    }
}
